\documentclass[a4paper,10pt]{article}

\usepackage{graphicx}
\usepackage[ansinew]{inputenc}
\usepackage[spanish]{babel}

\title{ \textbf{Trabajo pratico 0: Infraestructura basica}}

\author{ Martinez Luis Ariel, \textit{Padr\'on Nro. 88.573} \\
\texttt{ arielcorreofiuba@gmail.com } \\[2.5ex]
Arias Damian, \textit{Padr\'on Nro. 89.952} \\
\texttt{ arias.damian@gmail.com } \\[2.5ex]
Serraino Leandro, \textit{Padr\'on Nro. 87.033} \\
\texttt{ leo22ms@gmail.com } \\[2.5ex]
\normalsize{2do. Cuatrimestre de 2012} \\
\normalsize{66.20 Organizaci\'on de Computadoras $-$ Practica Martes} \\
\normalsize{Facultad de Ingenier\'ia, Universidad de Buenos Aires} \\
}

\date{}

\begin{document}

\maketitle
\thispagestyle{empty} % quita el nmero en la primer pgina


\section{Objetivos}
Familiarizarse con las herramientas de software que usaremos en los siguientes trabajos,
implementando un programa en lenguaje C que genere el volcado octal de una archivo
binario cualquiera, y la inversa.

\section{Disenio, implementaci\'on y validaci\'on}

\subsection{Conversi\'on binario a octal}
Para la escritura de cada byte (car\'acter) de entrada en el stream de salida, se utiliz\'o la funci\'on de C:\\
{\bf int fprintf (FILE *out, const char *template, ...)}\\
Usando esta funci\'on, se indica que se quiere escribir cada byte con el formato \%03o que se refiere a la forma octal del car\'acter.

Por otro lado, los bytes de entrada son leidos con un 'unsigned char' para garantizar que la representaci\'on de los mismos en octal sea de 3 d\'igitos.\\
Importante: se debe restringir la cantidad de bytes a dumpear cuando se utiliza el archivo generador random. Para aplicar esta restricci\'on se utiliza el comando {\bf head -cn /dev/random} donde {\bf n} es el nro de bytes a generar. A continuacion se escribe un pipe y luego la llamada usual al ejecutable {\bf ./tp0 parametros}. En los parametros no se deber\'a indicar el archivo de entrada.
\subsection{Conversi\'on octal a binario}

La conversi\'on se realiza leyendo de a 3 caracteres por vez (que son los 3 d\'igitos que describen a un byte en octal) y a partir de este string, se lo convierte al car\'acter original en binario. La funci\'on utilizada es la siguiente: \\
{\bf int sscanf (const char *nro\_ctal, const char *template, ...)}\\
La misma se usa indicando que el formato de lo que se va a leer es \%o (octal).

\section{Utilizaci\'on del programa}

Compilacion del programa:\\

{\bf host\$} gcc -Wall -o tp0 main.c \\

Para la utilizacion correr las pruebas listadas en la siguiente seccion

\section{Corridas de prueba}

\begin{enumerate}
\item {\bf test\_basico1.sh } \\

Proposito:
Comporbar la correcta codificacion de un archivo binario a uno octal, utilizando '' '' como delimitador y verificar que la decodificacion coincide con el archivo original. Esto se realiza mediante la ejecucion de las siguientes instrucciones\\

\$ echo -n ''test text.'' $>$ testfile.bin \\
\$ tp0 -l 4 -i testfile.bin -o testfile.oct \\
\$ tp0 -b -d '' '' -i testfile.oct -o testfile.bin.new \\
\$ diff -q testfile.bin.new testfile.bin \\

Entradas: \\
1) \\
test text. \\
2) \\
164 145 163 164 \\
040 164 145 170 \\
164 056 \\

Salidas: \\
1) \\
164 145 163 164 \\
040 164 145 170 \\
164 056 \\
2) \\
test text. \\

Resultados esperados: \\
1) \\
164 145 163 164 \\
040 164 145 170 \\
164 056 \\
2) \\
test text. \\

Comentario: \\
Se verifica el correcto funcionamiento de las mencionadas instrucciones, pues los resultados coinciden con los esperados. \\

\item {\bf test\_basico2.sh } \\

Proposito:
Comporbar la correcta codificacion de un archivo binario a uno octal, realizando la conversion sin delimitador y verificar que la decodificacion coincide con el archivo original. Esto se realiza mediante la ejecucion de las siguientes instrucciones\\

\$ echo -n ''test text.'' $>$ testfile.bin\\
\$ tp0 -l 4 -i testfile.bin -o testfile.oct\\
\$ tp0 -b -i testfile.oct -o testfile.bin.new\\
\$ diff -q testfile.bin.new testfile.bin\\

Entradas:\\
1)\\
test text.\\
2)\\
164145163164\\
040164145170\\
164056\\

Salidas:\\
1)\\
164145163164\\
040164145170\\
164056\\
2)\\
test text.\\
Resultados esperados:\\

1)\\
164145163164\\
040164145170\\
164056\\
2)\\
test text.\\

Comentario:\\
Se verifica el correcto funcionamiento de las mencionadas instrucciones, pues los resultados coinciden con los esperados.\\

\item {\bf test\_basico3.sh } \\

Proposito:\\
Comporbar la correcta codificacion de un archivo binario pasado por teclado a uno octal, utilizando para esto el siguiente comando \\

\$ ./tp0\\

Entrada:\\
1)\\
Quien pisa con suavidad va lejos.\\

Salida:\\
1)\\
1211651511451560401601511631410401431571560401631651411661511441411440401661\\41040154145152157163056012\\

Resultado esperado:\\
1)\\
1211651511451560401601511631410401431571560401631651411661511441411440401661\\41040154145152157163056012\\

Comentario:\\
Se verifica el correcto funcionamiento de las mencionadas instrucciones, pues el resultado coincide con el esperado.\\


\item {\bf test\_basico4.sh } \\

Proposito:\\
Comporbar la correcta codificacion de un archivo binario pasado por teclado a uno octal, utilizando para esto el siguiente comando \\

\$ ./tp0 -i -\\

Entrada:\\
1)\\
Quien pisa con suavidad va lejos.\\

Salida:\\
1)\\
1211651511451560401601511631410401431571560401631651411661511441411440401661\\41040154145152157163056012\\

Resultado esperado:\\
1)\\
1211651511451560401601511631410401431571560401631651411661511441411440401661\\41040154145152157163056012\\

Comentario:\\
Se verifica el correcto funcionamiento de las mencionadas instrucciones, pues el resultado coincide con el esperado.\\

\item {\bf test\_basico5.sh } \\


Proposito:\\
Comporbar la correcta codificacion de un archivo binario pasado por teclado a uno octal, utilizando para esto el siguiente comando \\

\$ ./tp0 -i - -o - -O\\

Entrada:\\
1)\\
Quien pisa con suavidad va lejos.\\

Salida:\\
1)\\
1211651511451560401601511631410401431571560401631651411661511441411440401661\\41040154145152157163056012\\

Resultado esperado:\\
1)\\
1211651511451560401601511631410401431571560401631651411661511441411440401661\\41040154145152157163056012\\

Comentario:\\
Se verifica el correcto funcionamiento de las mencionadas instrucciones, pues el resultado coincide con el esperado.\\

\item {\bf test\_Comparacion1.sh } \\

Proposito:\\
Comporbar la correcta codificacion de un archivo binario a uno octal, sin utilizar ningun delimitador y verificar que la decodificacion coincide con el archivo original. Esto se realiza mediante la ejecucion de las siguientes instrucciones\\

\$ echo -n ''Quien pisa con suavidad va lejos.'' $>$ testfile2.bin\\
\$ ./tp0 -i testfile2.bin -o testfile2.oct\\
\$ ./tp0 -b -i testfile2.oct -o testfile2.bin.new\\
\$ diff -q testfile2.bin.new testfile2.bin\\

Entrada:\\
1)\\
Quien pisa con suavidad va lejos.\\

Salida:\\
1)\\
1211651511451560401601511631410401431571560401631651411661511441411440401661\\41040154145152157163056012\\

Resultado esperado:\\
1)\\
1211651511451560401601511631410401431571560401631651411661511441411440401661\\41040154145152157163056012\\

Comentario:\\
Se verifica el correcto funcionamiento de las mencionadas instrucciones, pues los resultados coinciden con los esperados. Los resultados esperados son obtenidos de los siguientes sitios\\
a) http://nickciske.com/tools/octal.php\\
b) http://nickciske.com/tools/binary.php\\

\item {\bf test\_Comparacion2.sh } \\

Proposito:\\
Comporbar la correcta codificacion de un archivo octal a uno binario, sin utilizar ningun delimitador y verificar que la decodificacion coincide con el archivo original. Esto se realiza mediante la ejecucion de las siguientes instrucciones\\

\$ echo -n "12116515114515604016015116314104014315715604016316514116615114414114\\4040166141040154145152157163056" $>$ testfile3.bin\\
\$ ./tp0 -i testfile3.bin -o testfile3.oct\\
\$ ./tp0 -b -i testfile3.oct -o testfile3.bin.new\\
\$ diff -q testfile3.bin.new testfile3.bin\\

Entrada:\\
1)\\
12116515114515604016015116314104014315715604016316514116615114414114404016614104\\0154145152157163056\\

Salida:\\
1)\\
Quien pisa con suavidad va lejos.\\

Resultado esperado:\\
1)\\
Quien pisa con suavidad va lejos.\\

Comentario:\\
Se verifica el correcto funcionamiento de las mencionadas instrucciones, pues los resultados coinciden con los esperados. Estos resultados\\ esperados son obtenidos de los siguientes sitios\\
a) http://nickciske.com/tools/octal.php\\
b) http://nickciske.com/tools/binary.php\\

\item {\bf test\_Comparacion3.sh } \\

Proposito:\\
Comporbar la correcta codificacion de un archivo octal a uno binario, siendo el primero un archivo delimitado por ''.'' y con una longitud de 4 bytes. Luego verificar que la decodificacion coincide con el archivo original. Esto se realiza mediante la ejecucion de las siguientes instrucciones\\

\$ echo -n ''Quien pisa con suavidad va lejos.'' $>$ testfile4.bin\\
\$ ./tp0 -l 4 -d ''.'' -i testfile4.bin -o testfile4.oct\\
\$ ./tp0 -b -l 4 -d ''.'' -i testfile4.oct -o testfile4.bin.new\\
\$ diff -q testfile4.bin.new testfile4.bin\\

Entrada:\\
1)\\
Quien pisa con suavidad va lejos.\\

Salida:\\
1)\\
121.165.151.145\\
156.040.160.151\\
163.141.040.143\\
157.156.040.163\\
165.141.166.151\\
144.141.144.040\\
166.141.040.154\\
145.152.157.163\\
056\\

Resultado esperado:\\
1)\\
121.165.151.145\\
156.040.160.151\\
163.141.040.143\\
157.156.040.163\\
165.141.166.151\\
144.141.144.040\\
166.141.040.154\\
145.152.157.163\\
056\\

Comentario:\\
Se verifica el correcto funcionamiento de las mencionadas instrucciones, pues los resultados coinciden con los esperados. Estos resultados esperados son obtenidos de los siguientes sitios\\
a) http://nickciske.com/tools/octal.php\\
b) http://nickciske.com/tools/binary.php\\

\item {\bf test\_random.sh } \\

Proposito:\\
Comporbar la correcta codificacion de un archivo binario random tomado del sistema a octal, usando una longitud de 6 bytes por linea y ''$|$'' como delimitadior. Para esto se utilizo la siguiente instruccion\\

\$ head -c10 /dev/random $|$ ./tp0 -o /tmp/random-octaldump -l 6 -d ''$|$''\\

Comentario:\\
Se verifica el correcto funcionamiento de la mencionada instruccion, pues el archivo random codificado a octal, es el mismo que se obtiene luego de una decodificacion a binario y una nueva codificacion a octal.\\
Como se puede ver en los siguiente casos:\\

1)\\
Archivo random codificado a octal\\
323$|$111$|$265$|$217$|$143$|$171\\
271$|$223$|$232$|$150\\

Archivo anterior decodificado a binario\\
�I�y���h   (no son representable a caracteres legibles)\\ %todo: corregir este error de codificacion

Archivo anterior nuevamente codificado a octal\\
323$|$111$|$265$|$217$|$143$|$171\\
271$|$223$|$232$|$150\\

2)\\
Archivo random codificado a octal\\
061$|$221$|$074$|$117$|$062$|$145\\
065$|$156$|$126$|$375\\

Archivo anterior decodificado a binario\\
1�<O2e5nV      (no son representable a caracteres legibles)\\ %todo: corregir este error de codificacion

Archivo anterior nuevamente codificado a octal\\
061$|$221$|$074$|$117$|$062$|$145\\
065$|$156$|$126$|$375\\

\item {\bf test\_error1.sh } \\

Proposito:\\
Comporbar que no se puede codificar un archivo de entrada cuyo nombre supera la longitud maxima permitida, ni tampoco generar un archivo de salida cuyo nombre tambien supere la longitud maxima. Para lo cual se ejecutan las siguientes instrucciones.\\

\$ echo -n ''test text.'' $>$ testfileconnombredemasiadolargo.bin\\
\$ ./tp0 -d '' '' -i testfileconnombredemasiadolargo.bin -o testfile1.oct\\

\$ echo ''Se trata de codificar un archivo de salida cuyo nombre supera la longitud maxima permitida.''\\
\$ ./tp0 -b -d '' '' -i testfile1.oct -o testfileconnombredemasiadolargo.bin.new\\

Salida:\\
La long. del parametro <input file> supera los 30 caracteres\\
La long. del parametro <output file> supera los 30 caracteres\\

Comentario:\\
Se comprueba el correcto manejo de dicho error, pues la salida es la esperada.\\

\item {\bf test\_error2.sh } \\

Proposito:\\
Comporbar que no se puede codificar un archivo utilizando una cantidad de bytes octales por linea invalida. Para lo cual se ejecutan las siguientes instrucciones.\\

\$ echo -n "test text." $>$ testfile1.bin\\
\$ ./tp0 -l -d '' '' -i testfile1.bin -o testfile1.oct\\

Salida:\\
La longitud de linea propuesta es invalida\\

Comentario:\\
Se comprueba el correcto manejo de dicho error, pues la salida es la esperada.\\

\item {\bf test\_error3.sh } \\

Proposito:\\
Comporbar que no se puede ejecutar un comando en el cual hay un parametro no definido. Para lo cual se ejecutan las siguientes instrucciones.\\

\$ echo -n ''test text.'' $>$ testfile1.bin\\
\$ ./tp0 -r -d '' '' -i testfile1.bin -o testfile1.oct\\

Salida:\\
./tp0: invalid option -- 'r'\\
Parametro no valido: ?\\

Comentario:\\
Se comprueba el correcto manejo de dicho error, pues la salida es la esperada.\\

\item {\bf test\_error4.sh } \\

Proposito:\\
Comporbar que no se puede codificar de octal a binario, un archivo que no es octal. Para lo cual se ejecutan las siguientes instrucciones.\\

\$ echo -n ''test text.'' $>$ testfile1.oct\\
\$ ./tp0 -b -i testfile1.oct -o testfile1.bin\\

Salida:\\
Entrada invalida: (tes). Se esperaba un nro octal\\

Comentario:\\
Se comprueba el correcto manejo de dicho error, pues la salida es la esperada.\\

\item {\bf test\_error5.sh } \\

Proposito:\\
Comporbar que no se puede codificar a octal un archivo binario inexistente. Para lo cual se ejecutan las siguientes instrucciones.\\

\$ echo -n ''test text.'' $>$ testfile1.bin\\
\$ ./tp0 -d '' '' -i testfileinexistente.bin -o testfile1.oct\\

Salida:\\
No se pudo abrir el archivo testfileinexistente.bin\\

Comentario:\\
Se comprueba el correcto manejo de dicho error, pues la salida es la esperada.\\

\end{enumerate}


\section{C\'odigo fuente}

Esta incluido en este mismo informe como anexo

\section{C\'odigo MIPS}

Esta en el CD de entrega, no se lo puso en esta entraga impresa por ser demasiado extenso para imprimirlo\\

\newpage
\section{Conclusiones}

\begin{enumerate}
\item Si bien el lo solicitado por el programa no era excesivamente dif\'icil,
la realizaci\'on completa del TP llev\'o cierta dificultad al tener que
realizarlo en el contexto solicitado: alta portabilidad, desarrollo
en C, e informe hecho en LaTeX. 
\item En el primer caso la dificultad radicaba en tener configurado 
y funcionando el GXEmul dentro de un Linux, y lograr que en ambos casos 
el programa compile y corra sin problemas. 
\item Debido a nuestro desconocimiento con Latex, tuvimos que 
invertir tiempo en encontrar forma de realizar el presente documento 
de la manera m\'as correcta posible 
\item En cuanto al trabajo grupal en si mismo, no hubo inconvenientes de
ning\'un tipo ya que al ser el grupo relativamente chico y tener conocimiento
del manejo del versionado de un proyecto ante cambios ingresado por
los integrantes (por medio del SVN), la introducci\'on de modificaciones
y correcciones fu\'e fluida. 
\end{enumerate}
\begin{thebibliography}{99}

\bibitem{INT06} Intel Technology \& Research, ``Hyper-Threading Technology,'' 2006, http://www.intel.com/technology/hyperthread/.

\bibitem{HEN00} J. L. Hennessy and D. A. Patterson, ``Computer Architecture. A Quantitative
Approach,'' 3ra Edicin, Morgan Kaufmann Publishers, 2000.

\bibitem{LAR92} J. Larus and T. Ball, ``Rewriting Executable Files to Mesure Program Behavior,'' Tech. Report 1083, Univ. of Wisconsin, 1992.

\end{thebibliography}

\end{document}
